using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;

public class PriorityQueue<T> where T : IComparable<T>
{
	[CompilerGenerated]
	private sealed class _003CGetEnumerator_003Ed__14 : IEnumerator<T>, IEnumerator, IDisposable
	{
		private int _003C_003E1__state;

		private T _003C_003E2__current;

		public PriorityQueue<T> _003C_003E4__this;

		private List<T>.Enumerator _003C_003E7__wrap1;

		T IEnumerator<T>.Current
		{
			[DebuggerHidden]
			get
			{
				return default(T);
			}
		}

		object IEnumerator.Current
		{
			[DebuggerHidden]
			get
			{
				return null;
			}
		}

		[DebuggerHidden]
		public _003CGetEnumerator_003Ed__14(int _003C_003E1__state)
		{
		}

		[DebuggerHidden]
		void IDisposable.Dispose()
		{
		}

		private bool MoveNext()
		{
			return false;
		}

		bool IEnumerator.MoveNext()
		{
			//ILSpy generated this explicit interface implementation from .override directive in MoveNext
			return this.MoveNext();
		}

		private void _003C_003Em__Finally1()
		{
		}

		[DebuggerHidden]
		void IEnumerator.Reset()
		{
		}
	}

	private IComparer<T> _comparer;

	private int _type;

	private T[] _heap;

	private int _sz;

	private int _count;

	public PriorityQueue(int maxSize, IComparer<T> comparer)
	{
	}

	public PriorityQueue(int maxSize, int type = 0)
	{
	}

	private int Compare(T x, T y)
	{
		return 0;
	}

	public void Push(T x)
	{
	}

	public T Pop()
	{
		return default(T);
	}

	public int Count()
	{
		return 0;
	}

	public T Peek()
	{
		return default(T);
	}

	public bool Contains(T x)
	{
		return false;
	}

	public void Clear()
	{
	}

	[IteratorStateMachine(typeof(PriorityQueue<>._003CGetEnumerator_003Ed__14))]
	public IEnumerator<T> GetEnumerator()
	{
		return null;
	}

	public T[] ToArray()
	{
		return null;
	}
}
